perm filename PIXSAI.SAI[VIS,HPM]2 blob
sn#199655 filedate 1976-02-03 generic text, type C, neo UTF8
COMMENT ⊗ VALID 00011 PAGES
C REC PAGE DESCRIPTION
C00001 00001
C00003 00002 entry pixdim,pfldim,getpfl,putpfl,campix,makpix
C00008 00003 internal INTEGER PROCEDURE PFLDIM(STRING FILNAM)
C00011 00004 internal INTEGER PROCEDURE GETPFL(STRING FILNAM REFERENCE INTEGER PICTURE)
C00016 00005 internal INTEGER PROCEDURE PIXDIM(INTEGER HEIGHT,WIDTH,BITS)
C00019 00006 internal INTEGER PROCEDURE PUTPFL(REFERENCE INTEGER PICTURE STRING FILNAM)
C00021 00007 internal INTEGER PROCEDURE diminterest(REFERENCE INTEGER PICTURE INTEGER IW)
C00029 00008 INTERNAL PROCEDURE ENHANCE(REFERENCE INTEGER PIC)
C00030 00009 INTERNAL PROCEDURE SYNCHRONIZE(REFERENCE INTEGER PIC)
C00033 00010 INTERNAL INTEGER PROCEDURE CAMPIX(INTEGER CAMRA,YEDGE,XEDGE
C00040 00011 end
C00041 ENDMK
C⊗;
entry pixdim,pfldim,getpfl,putpfl,campix,makpix;
entry normalize, synchronize,diminterest,interest;
begin
DEFINE PCLN=0; comment index of word in a picture file containing
number of scanlines in the picture;
DEFINE PCWD=1; comment number of words in the picture;
DEFINE PCBY=2; comment number of valid bytes in the picture;
DEFINE PCBYA=3; comment no. of bytes including the nulls at the end of lines;
DEFINE LNWD=4; comment no. of words per scanline;
DEFINE LNBY=5; comment no. of valid bytes per scanline;
DEFINE LNBYA=6; comment no. of bytes per scanline, including the nulls;
DEFINE WDBY=7; comment no. of bytes per word;
DEFINE WDBI=8; comment no. of bits containing data in a word;
DEFINE BYBI=9; comment no. of bits per byte;
DEFINE BPTAB=10; comment address of second entry in byte pntr. table;
DEFINE LINTAB=11; comment actual address of the first entry in the row table;
EXTERNAL PROCEDURE MAKTAB(REFERENCE INTEGER PICTURE);
EXTERNAL INTEGER PROCEDURE INTOP(REFERENCE INTEGER PICTURE;
INTEGER WINSIZ;
REFERENCE INTEGER RESULTARRY;
INTEGER YEDGE(0),XEDGE(0));
EXTERNAL PROCEDURE GETPAR(REFERENCE INTEGER ARRY, PICTR);
EXTERNAL PROCEDURE PERBIT(REFERENCE INTEGER PICTURE, PERMUTATION);
EXTERNAL PROCEDURE HISTOG(REFERENCE INTEGER PICTURE, HISTOGRAM);
EXTERNAL PROCEDURE ROWSUM(REFERENCE INTEGER PICTURE, RWSUM);
EXTERNAL PROCEDURE ROWSUD(REFERENCE INTEGER PICTURE, RWSUM);
EXTERNAL INTEGER PROCEDURE CMPPAR(REFERENCE INTEGER PIC1,PIC2);
EXTERNAL PROCEDURE CLEAN(REFERENCE INTEGER PICTURE);
EXTERNAL PROCEDURE PASSHI(REFERENCE INTEGER PICTURE1;
INTEGER WINSIZ;
REFERENCE INTEGER PICTURE2);
EXTERNAL PROCEDURE HAFPIC(REFERENCE INTEGER PICTURE1,PICTURE2; INTEGER MAXBIT);
EXTERNAL INTEGER PROCEDURE MATCH(REFERENCE INTEGER PIC1,SY1,SX1,SY2,SX2;
REFERENCE INTEGER PIC2,DY1,DX1,DY2,DX2);
EXTERNAL PROCEDURE UNPACK(REFERENCE INTEGER SOURCEARRAY, PICTURE);
EXTERNAL PROCEDURE SELECT(REFERENCE INTEGER PICT1; INTEGER YEDGE,XEDGE;
REFERENCE INTEGER PICT2);
STRING PROCEDURE DEV(STRING FILSPEC);
BEGIN
STRING S,T;
INTEGER I;
S←FILSPEC;
T←"";
WHILE LENGTH(S)>0 ∧ S[1 TO 1]≠":" DO T←T&LOP(S);
RETURN(IF S[1 TO 1]=":" THEN T ELSE "DSK");
END;
STRING PROCEDURE NAM(STRING FILSPEC);
BEGIN
STRING S,T;
INTEGER I;
S←FILSPEC;
WHILE LENGTH(S)>0 ∧ S[1 TO 1]≠":" DO T←LOP(S);
RETURN(IF S[1 TO 1]=":" THEN S[2 TO ∞] ELSE FILSPEC);
END;
internal INTEGER PROCEDURE PFLDIM(STRING FILNAM);
comment returns the size of the picture FILNAM on disk.
used for allocating arrays in preparation for
actually reading them. Returns 0 on failure.;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER ARRAY BUF[0:'177];
OPEN(10,DEV(FILNAM),'10,2,0,XXCOUNT,XXBRCHAR,XXEOF);
LOOKUP(10,NAM(FILNAM),XXFLAG);
IF XXFLAG THEN
BEGIN
CLOSE(10);
RETURN(0);
END
ELSE
BEGIN
INTEGER K,KK;
ARRYIN(10,BUF[0],'200); CLOSE(10);
IF BUF[0]=-1 THEN
BEGIN
KK←0;
FOR K←18,17,16,15,10,9,8,7 DO IF BUF[K]≠0 THEN KK←K;
IF KK=0 THEN RETURN(0);
XBYBI←BUF[1];
XLNBY←BUF[6]-BUF[5]+1;
XPCLN←BUF[4]-BUF[3]+1;
XLNWD←BUF[2];
XLNBYA←XLNWD*(36%XBYBI);
XPCWD←XLNWD*XPCLN;
RETURN(12+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN
XBYBI←BUF[2];
XLNBY←BUF[8]-BUF[7]+1;
XPCLN←BUF[6]-BUF[5]+1;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
XPCBY←XPCLN*XLNBY;
XPCBYA←XPCLN*XLNBYA;
XWDBI←XWDBY*XBYBI;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN RETURN(0)
ELSE RETURN(12+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
internal INTEGER PROCEDURE GETPFL(STRING FILNAM; REFERENCE INTEGER PICTURE);
comment read the picture in file FILNAM into area of core whose first
word is PICTURE. PFLDIM(FILNAM) words are needed.
Returns picture size of success, 0 on failure.;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
INTEGER ARRAY BUF[0:'177];
OPEN(10,DEV(FILNAM),'10,2,0,XXCOUNT,XXBRCHAR,XXEOF);
LOOKUP(10,NAM(FILNAM),XXFLAG);
IF XXFLAG THEN
BEGIN
CLOSE(10);
RETURN(0);
END
ELSE
BEGIN
INTEGER K,KK;
ARRYIN(10,BUF[0],10);
IF BUF[0]=-1 THEN
BEGIN
ARRYIN(10,BUF[10],'200-10);
KK←0;
FOR K←18,17,16,15,10,9,8,7 DO IF BUF[K]≠0 THEN KK←K;
IF KK=0 THEN
BEGIN
CLOSE(10);
RETURN(0);
END;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[1];
MEMORY[L+LNBY]←XLNBY←BUF[6]-BUF[5]+1;
MEMORY[L+PCLN]←XPCLN←BUF[4]-BUF[3]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←BUF[2];
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+10]←12+XPCLN+L;
MAKTAB(PICTURE);
XXPICLOC←(BUF[KK] LAND '777777)-'200;
FOR I←1 STEP 1 UNTIL XXPICLOC DO WORDIN(10);
ARRYIN(10,MEMORY[L+12+XPCLN+XLNBYA],XPCWD);
CLOSE(10);
RETURN(12+XPCLN+XLNBYA+XPCWD);
END
ELSE
BEGIN comment if old hand eye format;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BUF[2];
MEMORY[L+LNBY]←XLNBY←BUF[8]-BUF[7]+1;
MEMORY[L+PCLN]←XPCLN←BUF[6]-BUF[5]+1;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+10]←12+XPCLN+L;
IF XBYBI≤0 ∨ XBYBI>36 ∨ XLNBY≤0 ∨ XPCLN≤0 ∨ BUF[0]<0 THEN
BEGIN
CLOSE(10);
RETURN(0);
END;
MAKTAB(PICTURE);
ARRYIN(10,MEMORY[L+12+XPCLN+XLNBYA],XPCWD);
CLOSE(10);
RETURN(12+XPCLN+XLNBYA+XPCWD);
END;
END;
END;
internal INTEGER PROCEDURE PIXDIM(INTEGER HEIGHT,WIDTH,BITS);
comment returns the size of the array needed to hold a hypothetical
picture HEIGHT scanlines by WIDTH pixels per scanline
by BITS bits per pixel.;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER L;
XBYBI←BITS;
XLNBY←WIDTH;
XPCLN←HEIGHT;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
XPCWD←XPCLN*XLNWD;
RETURN(12+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE MAKPIX(INTEGER HEIGHT,WIDTH,BITS; REFERENCE INTEGER PICTURE);
comment actually creates an empty picture HEIGHT by WIDTH by BITS in
the area of core beginning with PICTURE. Returns its size.;
BEGIN
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
L←LOCATION(PICTURE);
MEMORY[L+BYBI]←XBYBI←BITS;
MEMORY[L+LNBY]←XLNBY←WIDTH;
MEMORY[L+PCLN]←XPCLN←HEIGHT;
MEMORY[L+WDBY]←XWDBY←36%XBYBI;
MEMORY[L+LNWD]←XLNWD←(XLNBY+XWDBY-1)%XWDBY;
MEMORY[L+LNBYA]←XLNBYA←XLNWD*XWDBY;
MEMORY[L+PCWD]←XPCWD←XPCLN*XLNWD;
MEMORY[L+PCBY]←XPCBY←XPCLN*XLNBY;
MEMORY[L+PCBYA]←XPCBYA←XPCLN*XLNBYA;
MEMORY[L+WDBI]←XWDBI←XWDBY*XBYBI;
MEMORY[L+10]←12+XPCLN+L;
MAKTAB(PICTURE);
RETURN(12+XPCLN+XLNBYA+XPCWD);
END;
internal INTEGER PROCEDURE PUTPFL(REFERENCE INTEGER PICTURE; STRING FILNAM);
comment write out the picture in the core area starting with
PICTURE, creating a file called FILNAM. Returns
the size of the original file on success, else 0.;
BEGIN
INTEGER XXCOUNT,XXBRCHAR,XXEOF,XXPICLOC; BOOLEAN XXFLAG;
INTEGER XPCLN,XPCWD,XPCBY,XPCBYA,XLNWD,XLNBY,XLNBYA,XWDBY,XWDBI,XBYBI;
INTEGER I,L;
INTEGER ARRAY BUF[0:'177];
OPEN(10,DEV(FILNAM),'10,0,2,XXCOUNT,XXBRCHAR,XXEOF);
ENTER(10,NAM(FILNAM),XXFLAG);
IF XXFLAG THEN
BEGIN
CLOSE(10);
RETURN(0);
END
ELSE
BEGIN
L←LOCATION(PICTURE);
BUF[0]←-1;
BUF[1]←XBYBI←MEMORY[L+BYBI];
BUF[2]←XLNWD←MEMORY[L+LNWD];
BUF[3]←1; BUF[4]←XPCLN←MEMORY[L+PCLN];
BUF[5]←1; BUF[6]←XLNBY←MEMORY[L+LNBY];
BUF[7]←((-(XPCWD←MEMORY[L+PCWD])) LSH 18) LOR '200;
XWDBY←36%XBYBI;
XLNWD←(XLNBY+XWDBY-1)%XWDBY;
XLNBYA←XLNWD*XWDBY;
ARRYOUT(10,BUF[0],'200);
ARRYOUT(10,MEMORY[L+12+XPCLN+XLNBYA],XPCWD);
CLOSE(10);
RETURN(12+XPCLN+XLNBYA+XPCWD);
END;
END;
internal INTEGER PROCEDURE diminterest(REFERENCE INTEGER PICTURE; INTEGER IW);
BEGIN
INTEGER HIG,WID,BITS;
HIG←MEMORY[LOCATION(PICTURE)+PCLN];
WID←MEMORY[LOCATION(PICTURE)+LNBY];
BITS←MEMORY[LOCATION(PICTURE)+BYBI];
RETURN(PIXDIM((HIG-1)%IW,(WID-1)%IW,10));
END;
internal PROCEDURE INTEREST(REFERENCE INTEGER PICTURE; INTEGER IW;
REFERENCE INTEGER RESULT);
BEGIN
INTEGER HIG,WID,BITS,IAV,I,J,IWW,BYMAX;
EXTERNAL PROCEDURE GETPAR(REFERENCE INTEGER ARY, PICT);
HIG←MEMORY[LOCATION(PICTURE)+PCLN];
WID←MEMORY[LOCATION(PICTURE)+LNBY];
BITS←MEMORY[LOCATION(PICTURE)+BYBI];
BEGIN
INTEGER ARRAY INTER[-2:(HIG-1)%IW-1,0:(WID-1)%IW-1];
IAV←INTOP(PICTURE,IW,INTER[0,0]);
IWW←IW*IW;
BYMAX←2↑BITS-1;
FOR I←(HIG-1)%IW-1 STEP -1 UNTIL 0 DO
FOR J←(WID-1)%IW-1 STEP -1 UNTIL 0 DO
INTER[I,J]←8*SQRT(INTER[I,J]/IWW) MIN BYMAX;
MAKPIX((HIG-1)%IW,(WID-1)%IW,BITS,RESULT);
GETPAR(INTER[0,0],RESULT);
END;
END;
INTERNAL PROCEDURE ENHANCE(REFERENCE INTEGER PIC);
BEGIN
INTEGER INTEG,I,TOT,BITS,SAMPS;
BITS←MEMORY[LOCATION(PIC)+BYBI];
SAMPS←2↑BITS;
BEGIN
INTEGER ARRAY GREYS[0:SAMPS-1];
HISTOG(PIC,GREYS[0]);
TOT←0;
FOR I←0 STEP 1 UNTIL SAMPS-1 DO TOT←TOT+GREYS[I];
INTEG←0;
FOR I←0 STEP 1 UNTIL SAMPS-1 DO
BEGIN
INTEG←INTEG+GREYS[I];
GREYS[I]←(SAMPS-1)*INTEG/TOT;
END;
PERBIT(PIC,GREYS[0]);
END;
END;
INTERNAL PROCEDURE SYNCHRONIZE(REFERENCE INTEGER PIC);
BEGIN
INTEGER I,J,K,WINPOS,HIG;
REAL WINVAL,TRIALVAL;
HIG←MEMORY[LOCATION(PIC)+PCLN];
BEGIN
INTEGER ARRAY ROWSM[0:HIG-1];
DEFINE DK=".6";
ROWSUD(PIC,ROWSM[0]);
WINPOS←HIG-1;
WINVAL←ROWSM[HIG-1];
FOR I←0 STEP 1 UNTIL HIG-1 DO WINVAL←WINVAL*DK + ROWSM[I]*(1-DK);
TRIALVAL←WINVAL;
FOR J←0 STEP 1 UNTIL HIG-1 DO
BEGIN
TRIALVAL←TRIALVAL*DK + ROWSM[J]*(1-DK);
IF TRIALVAL≤WINVAL THEN
BEGIN
WINVAL←TRIALVAL;
WINPOS←J;
END;
END;
IF WINPOS<HIG-1 THEN
BEGIN
INTEGER BODY,BODYSIZ;
INTEGER ARRAY COPY[0:BODYSIZ←MEMORY[LOCATION(PIC)+PCWD]];
BODY←MEMORY[LOCATION(PIC)+LINTAB];
WINPOS←(WINPOS+1)*MEMORY[LOCATION(PIC)+LNWD];
ARRBLT(COPY[0],MEMORY[BODY+WINPOS],BODYSIZ-WINPOS);
ARRBLT(COPY[BODYSIZ-WINPOS],MEMORY[BODY],WINPOS);
ARRBLT(MEMORY[BODY],COPY[0],BODYSIZ);
END;
END;
END;
INTERNAL INTEGER PROCEDURE CAMPIX(INTEGER CAMRA,YEDGE,XEDGE;
REFERENCE INTEGER PICTURE;
INTEGER SUMS(1),BCLIP(7),TCLIP(0),NTRY(200));
comment read a picture from camera CAMRA of size defined by array PICTURE
the area of core beginning with PICTURE. Upper left hand
corner is at PICX,PICY. SUMS and CLPINC are averaging params.;
BEGIN
EXTERNAL INTEGER PROCEDURE TVSNAP(INTEGER CAM,YEDG,XEDG;
REFERENCE INTEGER PIC;
INTEGER BCLIP,TCLIP,NTRY);
EXTERNAL INTEGER PROCEDURE TVRAW(INTEGER CAM,YEDG,XEDG;
REFERENCE INTEGER PIC;
INTEGER BCLIP,TCLIP,NTRY);
EXTERNAL PROCEDURE WIPE(REFERENCE INTEGER PICTURE; INTEGER VALUE);
EXTERNAL PROCEDURE TVBTMX(REFERENCE INTEGER PIC4,PICN,XFRM; INTEGER TOPV(7));
EXTERNAL PROCEDURE PICADD(REFERENCE INTEGER PICTURE,PICSUM);
EXTERNAL PROCEDURE SHRINK(REFERENCE INTEGER PIC1,PIC2);
EXTERNAL PROCEDURE PICSH(REFERENCE INTEGER PIC1,PIC2; INTEGER DIV);
INTEGER XPCLN,XLNBY,XBYBI;
INTEGER L,CAM,DW,ERS,I,J,K,NDEL;
PRELOAD_WITH '12,'13,'11,'10,'15,'14,'16,'17,'5,'4,'6,'7,'2,'3,'1,'0;
OWN INTEGER ARRAY GREY[0:15];
IF CAMRA>'40 THEN CAMRA←CAMRA LAND '67;
IF CAMRA='41∨CAMRA='42 THEN CAM←CAMRA LAND 3 ELSE
BEGIN
INTEGER I,J;
I←'401400000000 LOR LOCATION(J);
J←IF CAMRA≥'40 THEN CAMRA LAND 7 ELSE 1 LSH (35-CAMRA);
START_CODE
MOVE 1,I;
CALLI 1,'400070; COMMENT VDSMAP;
JUMP 0,0;
END;
CAM←3;
END;
L←LOCATION(PICTURE);
XPCLN←MEMORY[L+PCLN];
XLNBY←MEMORY[L+LNBY];
XBYBI←MEMORY[L+BYBI];
NDEL←0; SUMS←SUMS MAX 1;
BEGIN
INTEGER ARRAY T1[0:IF XBYBI≠4 THEN PIXDIM(XPCLN,XLNBY,4) ELSE 0],
T[0:IF SUMS>1 THEN PIXDIM(XPCLN,XLNBY,12) ELSE 0];
IF XBYBI≠4 THEN MAKPIX(XPCLN,XLNBY,4,T1[0]);
IF SUMS>1 THEN
BEGIN
MAKPIX(XPCLN,XLNBY,12,T[0]);
WIPE(T[0],0);
END;
ERS←0;
FOR K←1 STEP 1 UNTIL SUMS DO
BEGIN
IF XBYBI>4 THEN
BEGIN
INTEGER CLPINC,TC,BC,CLPSTP;
INTEGER MXBY;
MXBY←2↑XBYBI-1;
CLPINC←(BCLIP-TCLIP+1)*15/MXBY;
CLPINC←((CLPINC MAX 1) MIN 7);
CLPSTP←CLPINC%2 MAX 1;
WIPE(PICTURE,-1);
TC←TCLIP;
DO
BEGIN
INTEGER ARRAY XFRM[0:15];
REAL TM,BM;
BC←TC+CLPINC-1;
TM←(BCLIP+1-TC)*MXBY/(BCLIP-TCLIP+1);
BM←(BCLIP-BC)*MXBY/(BCLIP-TCLIP+1);
FOR I←0 STEP 1 UNTIL 15 DO
XFRM[I]←
((2*GREY[I]*(TM-BM)+TM+29*BM)/30 MAX 0) MIN MXBY;
DW←TVRAW(CAM,YEDGE,XEDGE,T1[0],BC,TC,NDEL←NDEL+NTRY);
IF DW≥0 THEN
BEGIN
TVBTMX(T1[0],PICTURE,XFRM[0],7);
TC←TC+CLPSTP;
END;
END
UNTIL BC≥BCLIP∨DW<0;
ERS←ERS+DW;
END
ELSE
IF XBYBI=4 THEN
DW←TVSNAP(CAM,YEDGE,XEDGE,PICTURE,BCLIP,TCLIP,NDEL←NDEL+NTRY)
ELSE
IF XBYBI<4 THEN
DW←TVSNAP(CAM,YEDGE,XEDGE,T1[0],BCLIP,TCLIP,NDEL←NDEL+NTRY);
IF DW≥0 THEN
BEGIN
IF SUMS>1 THEN PICADD(PICTURE,T[0]);
ERS←ERS+DW;
END
ELSE
BEGIN
K←SUMS;
ERS←-1;
END;
END;
IF ERS≥0 THEN
IF SUMS>1 THEN PICSH(T[0],PICTURE,SUMS) ELSE
IF XBYBI<4 THEN SHRINK(T1[0],PICTURE);
END;
RETURN(ERS);
END;
end